home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / xpconnect / xpccomponents.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  29KB  |  935 lines
  1. /*
  2.  * DO NOT EDIT.  THIS FILE IS GENERATED FROM xpccomponents.idl
  3.  */
  4.  
  5. #ifndef __gen_xpccomponents_h__
  6. #define __gen_xpccomponents_h__
  7.  
  8.  
  9. #ifndef __gen_nsISupports_h__
  10. #include "nsISupports.h"
  11. #endif
  12.  
  13. #ifndef __gen_xpcexception_h__
  14. #include "xpcexception.h"
  15. #endif
  16.  
  17. #ifndef __gen_xpcjsid_h__
  18. #include "xpcjsid.h"
  19. #endif
  20.  
  21. #ifndef __gen_nsIComponentManager_h__
  22. #include "nsIComponentManager.h"
  23. #endif
  24.  
  25. #ifndef __gen_nsIScriptableInterfaces_h__
  26. #include "nsIScriptableInterfaces.h"
  27. #endif
  28.  
  29. /* For IDL files that don't want to include root IDL files. */
  30. #ifndef NS_NO_VTABLE
  31. #define NS_NO_VTABLE
  32. #endif
  33.  
  34. /* starting interface:    nsIXPCComponents_Classes */
  35. #define NS_IXPCCOMPONENTS_CLASSES_IID_STR "978ff520-d26c-11d2-9842-006008962422"
  36.  
  37. #define NS_IXPCCOMPONENTS_CLASSES_IID \
  38.   {0x978ff520, 0xd26c, 0x11d2, \
  39.     { 0x98, 0x42, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}
  40.  
  41. /**
  42. * interface of Components.classes
  43. * (interesting stuff only reflected into JavaScript)
  44. */
  45. class NS_NO_VTABLE nsIXPCComponents_Classes : public nsISupports {
  46.  public: 
  47.  
  48.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_CLASSES_IID)
  49.  
  50. };
  51.  
  52. /* Use this macro when declaring classes that implement this interface. */
  53. #define NS_DECL_NSIXPCCOMPONENTS_CLASSES \
  54.   /* no methods! */
  55.  
  56. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  57. #define NS_FORWARD_NSIXPCCOMPONENTS_CLASSES(_to) \
  58.   /* no methods! */
  59.  
  60. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  61. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS_CLASSES(_to) \
  62.   /* no methods! */
  63.  
  64. #if 0
  65. /* Use the code below as a template for the implementation class for this interface. */
  66.  
  67. /* Header file */
  68. class nsXPCComponents_Classes : public nsIXPCComponents_Classes
  69. {
  70. public:
  71.   NS_DECL_ISUPPORTS
  72.   NS_DECL_NSIXPCCOMPONENTS_CLASSES
  73.  
  74.   nsXPCComponents_Classes();
  75.  
  76. private:
  77.   ~nsXPCComponents_Classes();
  78.  
  79. protected:
  80.   /* additional members */
  81. };
  82.  
  83. /* Implementation file */
  84. NS_IMPL_ISUPPORTS1(nsXPCComponents_Classes, nsIXPCComponents_Classes)
  85.  
  86. nsXPCComponents_Classes::nsXPCComponents_Classes()
  87. {
  88.   /* member initializers and constructor code */
  89. }
  90.  
  91. nsXPCComponents_Classes::~nsXPCComponents_Classes()
  92. {
  93.   /* destructor code */
  94. }
  95.  
  96. /* End of implementation class template. */
  97. #endif
  98.  
  99.  
  100. /* starting interface:    nsIXPCComponents_ClassesByID */
  101. #define NS_IXPCCOMPONENTS_CLASSESBYID_IID_STR "336a9590-4d19-11d3-9893-006008962422"
  102.  
  103. #define NS_IXPCCOMPONENTS_CLASSESBYID_IID \
  104.   {0x336a9590, 0x4d19, 0x11d3, \
  105.     { 0x98, 0x93, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}
  106.  
  107. /**
  108. * interface of Components.classesByID
  109. * (interesting stuff only reflected into JavaScript)
  110. */
  111. class NS_NO_VTABLE nsIXPCComponents_ClassesByID : public nsISupports {
  112.  public: 
  113.  
  114.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_CLASSESBYID_IID)
  115.  
  116. };
  117.  
  118. /* Use this macro when declaring classes that implement this interface. */
  119. #define NS_DECL_NSIXPCCOMPONENTS_CLASSESBYID \
  120.   /* no methods! */
  121.  
  122. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  123. #define NS_FORWARD_NSIXPCCOMPONENTS_CLASSESBYID(_to) \
  124.   /* no methods! */
  125.  
  126. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  127. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS_CLASSESBYID(_to) \
  128.   /* no methods! */
  129.  
  130. #if 0
  131. /* Use the code below as a template for the implementation class for this interface. */
  132.  
  133. /* Header file */
  134. class nsXPCComponents_ClassesByID : public nsIXPCComponents_ClassesByID
  135. {
  136. public:
  137.   NS_DECL_ISUPPORTS
  138.   NS_DECL_NSIXPCCOMPONENTS_CLASSESBYID
  139.  
  140.   nsXPCComponents_ClassesByID();
  141.  
  142. private:
  143.   ~nsXPCComponents_ClassesByID();
  144.  
  145. protected:
  146.   /* additional members */
  147. };
  148.  
  149. /* Implementation file */
  150. NS_IMPL_ISUPPORTS1(nsXPCComponents_ClassesByID, nsIXPCComponents_ClassesByID)
  151.  
  152. nsXPCComponents_ClassesByID::nsXPCComponents_ClassesByID()
  153. {
  154.   /* member initializers and constructor code */
  155. }
  156.  
  157. nsXPCComponents_ClassesByID::~nsXPCComponents_ClassesByID()
  158. {
  159.   /* destructor code */
  160. }
  161.  
  162. /* End of implementation class template. */
  163. #endif
  164.  
  165.  
  166. /* starting interface:    nsIXPCComponents_Results */
  167. #define NS_IXPCCOMPONENTS_RESULTS_IID_STR "2fc229a0-5860-11d3-9899-006008962422"
  168.  
  169. #define NS_IXPCCOMPONENTS_RESULTS_IID \
  170.   {0x2fc229a0, 0x5860, 0x11d3, \
  171.     { 0x98, 0x99, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}
  172.  
  173. /**
  174. * interface of Components.results
  175. * (interesting stuff only reflected into JavaScript)
  176. */
  177. class NS_NO_VTABLE nsIXPCComponents_Results : public nsISupports {
  178.  public: 
  179.  
  180.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_RESULTS_IID)
  181.  
  182. };
  183.  
  184. /* Use this macro when declaring classes that implement this interface. */
  185. #define NS_DECL_NSIXPCCOMPONENTS_RESULTS \
  186.   /* no methods! */
  187.  
  188. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  189. #define NS_FORWARD_NSIXPCCOMPONENTS_RESULTS(_to) \
  190.   /* no methods! */
  191.  
  192. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  193. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS_RESULTS(_to) \
  194.   /* no methods! */
  195.  
  196. #if 0
  197. /* Use the code below as a template for the implementation class for this interface. */
  198.  
  199. /* Header file */
  200. class nsXPCComponents_Results : public nsIXPCComponents_Results
  201. {
  202. public:
  203.   NS_DECL_ISUPPORTS
  204.   NS_DECL_NSIXPCCOMPONENTS_RESULTS
  205.  
  206.   nsXPCComponents_Results();
  207.  
  208. private:
  209.   ~nsXPCComponents_Results();
  210.  
  211. protected:
  212.   /* additional members */
  213. };
  214.  
  215. /* Implementation file */
  216. NS_IMPL_ISUPPORTS1(nsXPCComponents_Results, nsIXPCComponents_Results)
  217.  
  218. nsXPCComponents_Results::nsXPCComponents_Results()
  219. {
  220.   /* member initializers and constructor code */
  221. }
  222.  
  223. nsXPCComponents_Results::~nsXPCComponents_Results()
  224. {
  225.   /* destructor code */
  226. }
  227.  
  228. /* End of implementation class template. */
  229. #endif
  230.  
  231.  
  232. /* starting interface:    nsIXPCComponents_ID */
  233. #define NS_IXPCCOMPONENTS_ID_IID_STR "7994a6e0-e028-11d3-8f5d-0010a4e73d9a"
  234.  
  235. #define NS_IXPCCOMPONENTS_ID_IID \
  236.   {0x7994a6e0, 0xe028, 0x11d3, \
  237.     { 0x8f, 0x5d, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}
  238.  
  239. /**
  240. * interface of Components.ID
  241. * (interesting stuff only reflected into JavaScript)
  242. */
  243. class NS_NO_VTABLE nsIXPCComponents_ID : public nsISupports {
  244.  public: 
  245.  
  246.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_ID_IID)
  247.  
  248. };
  249.  
  250. /* Use this macro when declaring classes that implement this interface. */
  251. #define NS_DECL_NSIXPCCOMPONENTS_ID \
  252.   /* no methods! */
  253.  
  254. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  255. #define NS_FORWARD_NSIXPCCOMPONENTS_ID(_to) \
  256.   /* no methods! */
  257.  
  258. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  259. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS_ID(_to) \
  260.   /* no methods! */
  261.  
  262. #if 0
  263. /* Use the code below as a template for the implementation class for this interface. */
  264.  
  265. /* Header file */
  266. class nsXPCComponents_ID : public nsIXPCComponents_ID
  267. {
  268. public:
  269.   NS_DECL_ISUPPORTS
  270.   NS_DECL_NSIXPCCOMPONENTS_ID
  271.  
  272.   nsXPCComponents_ID();
  273.  
  274. private:
  275.   ~nsXPCComponents_ID();
  276.  
  277. protected:
  278.   /* additional members */
  279. };
  280.  
  281. /* Implementation file */
  282. NS_IMPL_ISUPPORTS1(nsXPCComponents_ID, nsIXPCComponents_ID)
  283.  
  284. nsXPCComponents_ID::nsXPCComponents_ID()
  285. {
  286.   /* member initializers and constructor code */
  287. }
  288.  
  289. nsXPCComponents_ID::~nsXPCComponents_ID()
  290. {
  291.   /* destructor code */
  292. }
  293.  
  294. /* End of implementation class template. */
  295. #endif
  296.  
  297.  
  298. /* starting interface:    nsIXPCComponents_Exception */
  299. #define NS_IXPCCOMPONENTS_EXCEPTION_IID_STR "5bf039c0-e028-11d3-8f5d-0010a4e73d9a"
  300.  
  301. #define NS_IXPCCOMPONENTS_EXCEPTION_IID \
  302.   {0x5bf039c0, 0xe028, 0x11d3, \
  303.     { 0x8f, 0x5d, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}
  304.  
  305. /**
  306. * interface of Components.Exception
  307. * (interesting stuff only reflected into JavaScript)
  308. */
  309. class NS_NO_VTABLE nsIXPCComponents_Exception : public nsISupports {
  310.  public: 
  311.  
  312.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_EXCEPTION_IID)
  313.  
  314. };
  315.  
  316. /* Use this macro when declaring classes that implement this interface. */
  317. #define NS_DECL_NSIXPCCOMPONENTS_EXCEPTION \
  318.   /* no methods! */
  319.  
  320. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  321. #define NS_FORWARD_NSIXPCCOMPONENTS_EXCEPTION(_to) \
  322.   /* no methods! */
  323.  
  324. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  325. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS_EXCEPTION(_to) \
  326.   /* no methods! */
  327.  
  328. #if 0
  329. /* Use the code below as a template for the implementation class for this interface. */
  330.  
  331. /* Header file */
  332. class nsXPCComponents_Exception : public nsIXPCComponents_Exception
  333. {
  334. public:
  335.   NS_DECL_ISUPPORTS
  336.   NS_DECL_NSIXPCCOMPONENTS_EXCEPTION
  337.  
  338.   nsXPCComponents_Exception();
  339.  
  340. private:
  341.   ~nsXPCComponents_Exception();
  342.  
  343. protected:
  344.   /* additional members */
  345. };
  346.  
  347. /* Implementation file */
  348. NS_IMPL_ISUPPORTS1(nsXPCComponents_Exception, nsIXPCComponents_Exception)
  349.  
  350. nsXPCComponents_Exception::nsXPCComponents_Exception()
  351. {
  352.   /* member initializers and constructor code */
  353. }
  354.  
  355. nsXPCComponents_Exception::~nsXPCComponents_Exception()
  356. {
  357.   /* destructor code */
  358. }
  359.  
  360. /* End of implementation class template. */
  361. #endif
  362.  
  363.  
  364. /* starting interface:    nsIXPCComponents_Constructor */
  365. #define NS_IXPCCOMPONENTS_CONSTRUCTOR_IID_STR "88655640-e028-11d3-8f5d-0010a4e73d9a"
  366.  
  367. #define NS_IXPCCOMPONENTS_CONSTRUCTOR_IID \
  368.   {0x88655640, 0xe028, 0x11d3, \
  369.     { 0x8f, 0x5d, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}
  370.  
  371. /**
  372. * interface of Components.Constructor
  373. * (interesting stuff only reflected into JavaScript)
  374. */
  375. class NS_NO_VTABLE nsIXPCComponents_Constructor : public nsISupports {
  376.  public: 
  377.  
  378.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_CONSTRUCTOR_IID)
  379.  
  380. };
  381.  
  382. /* Use this macro when declaring classes that implement this interface. */
  383. #define NS_DECL_NSIXPCCOMPONENTS_CONSTRUCTOR \
  384.   /* no methods! */
  385.  
  386. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  387. #define NS_FORWARD_NSIXPCCOMPONENTS_CONSTRUCTOR(_to) \
  388.   /* no methods! */
  389.  
  390. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  391. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS_CONSTRUCTOR(_to) \
  392.   /* no methods! */
  393.  
  394. #if 0
  395. /* Use the code below as a template for the implementation class for this interface. */
  396.  
  397. /* Header file */
  398. class nsXPCComponents_Constructor : public nsIXPCComponents_Constructor
  399. {
  400. public:
  401.   NS_DECL_ISUPPORTS
  402.   NS_DECL_NSIXPCCOMPONENTS_CONSTRUCTOR
  403.  
  404.   nsXPCComponents_Constructor();
  405.  
  406. private:
  407.   ~nsXPCComponents_Constructor();
  408.  
  409. protected:
  410.   /* additional members */
  411. };
  412.  
  413. /* Implementation file */
  414. NS_IMPL_ISUPPORTS1(nsXPCComponents_Constructor, nsIXPCComponents_Constructor)
  415.  
  416. nsXPCComponents_Constructor::nsXPCComponents_Constructor()
  417. {
  418.   /* member initializers and constructor code */
  419. }
  420.  
  421. nsXPCComponents_Constructor::~nsXPCComponents_Constructor()
  422. {
  423.   /* destructor code */
  424. }
  425.  
  426. /* End of implementation class template. */
  427. #endif
  428.  
  429.  
  430. /* starting interface:    nsIXPCConstructor */
  431. #define NS_IXPCCONSTRUCTOR_IID_STR "c814ca20-e0dc-11d3-8f5f-0010a4e73d9a"
  432.  
  433. #define NS_IXPCCONSTRUCTOR_IID \
  434.   {0xc814ca20, 0xe0dc, 0x11d3, \
  435.     { 0x8f, 0x5f, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}
  436.  
  437. /**
  438. * interface of object returned by Components.Constructor
  439. * (additional interesting stuff only reflected into JavaScript)
  440. */
  441. class NS_NO_VTABLE nsIXPCConstructor : public nsISupports {
  442.  public: 
  443.  
  444.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCONSTRUCTOR_IID)
  445.  
  446.   /* readonly attribute nsIJSCID classID; */
  447.   NS_IMETHOD GetClassID(nsIJSCID * *aClassID) = 0;
  448.  
  449.   /* readonly attribute nsIJSIID interfaceID; */
  450.   NS_IMETHOD GetInterfaceID(nsIJSIID * *aInterfaceID) = 0;
  451.  
  452.   /* readonly attribute string initializer; */
  453.   NS_IMETHOD GetInitializer(char * *aInitializer) = 0;
  454.  
  455. };
  456.  
  457. /* Use this macro when declaring classes that implement this interface. */
  458. #define NS_DECL_NSIXPCCONSTRUCTOR \
  459.   NS_IMETHOD GetClassID(nsIJSCID * *aClassID); \
  460.   NS_IMETHOD GetInterfaceID(nsIJSIID * *aInterfaceID); \
  461.   NS_IMETHOD GetInitializer(char * *aInitializer); 
  462.  
  463. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  464. #define NS_FORWARD_NSIXPCCONSTRUCTOR(_to) \
  465.   NS_IMETHOD GetClassID(nsIJSCID * *aClassID) { return _to GetClassID(aClassID); } \
  466.   NS_IMETHOD GetInterfaceID(nsIJSIID * *aInterfaceID) { return _to GetInterfaceID(aInterfaceID); } \
  467.   NS_IMETHOD GetInitializer(char * *aInitializer) { return _to GetInitializer(aInitializer); } 
  468.  
  469. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  470. #define NS_FORWARD_SAFE_NSIXPCCONSTRUCTOR(_to) \
  471.   NS_IMETHOD GetClassID(nsIJSCID * *aClassID) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetClassID(aClassID); } \
  472.   NS_IMETHOD GetInterfaceID(nsIJSIID * *aInterfaceID) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetInterfaceID(aInterfaceID); } \
  473.   NS_IMETHOD GetInitializer(char * *aInitializer) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetInitializer(aInitializer); } 
  474.  
  475. #if 0
  476. /* Use the code below as a template for the implementation class for this interface. */
  477.  
  478. /* Header file */
  479. class nsXPCConstructor : public nsIXPCConstructor
  480. {
  481. public:
  482.   NS_DECL_ISUPPORTS
  483.   NS_DECL_NSIXPCCONSTRUCTOR
  484.  
  485.   nsXPCConstructor();
  486.  
  487. private:
  488.   ~nsXPCConstructor();
  489.  
  490. protected:
  491.   /* additional members */
  492. };
  493.  
  494. /* Implementation file */
  495. NS_IMPL_ISUPPORTS1(nsXPCConstructor, nsIXPCConstructor)
  496.  
  497. nsXPCConstructor::nsXPCConstructor()
  498. {
  499.   /* member initializers and constructor code */
  500. }
  501.  
  502. nsXPCConstructor::~nsXPCConstructor()
  503. {
  504.   /* destructor code */
  505. }
  506.  
  507. /* readonly attribute nsIJSCID classID; */
  508. NS_IMETHODIMP nsXPCConstructor::GetClassID(nsIJSCID * *aClassID)
  509. {
  510.     return NS_ERROR_NOT_IMPLEMENTED;
  511. }
  512.  
  513. /* readonly attribute nsIJSIID interfaceID; */
  514. NS_IMETHODIMP nsXPCConstructor::GetInterfaceID(nsIJSIID * *aInterfaceID)
  515. {
  516.     return NS_ERROR_NOT_IMPLEMENTED;
  517. }
  518.  
  519. /* readonly attribute string initializer; */
  520. NS_IMETHODIMP nsXPCConstructor::GetInitializer(char * *aInitializer)
  521. {
  522.     return NS_ERROR_NOT_IMPLEMENTED;
  523. }
  524.  
  525. /* End of implementation class template. */
  526. #endif
  527.  
  528.  
  529. /* starting interface:    nsIXPCComponents_utils_Sandbox */
  530. #define NS_IXPCCOMPONENTS_UTILS_SANDBOX_IID_STR "4f8ae0dc-d266-4a32-875b-6a9de71a8ce9"
  531.  
  532. #define NS_IXPCCOMPONENTS_UTILS_SANDBOX_IID \
  533.   {0x4f8ae0dc, 0xd266, 0x4a32, \
  534.     { 0x87, 0x5b, 0x6a, 0x9d, 0xe7, 0x1a, 0x8c, 0xe9 }}
  535.  
  536. /**
  537. * interface of object returned by Components.utils.Sandbox.
  538. */
  539. class NS_NO_VTABLE nsIXPCComponents_utils_Sandbox : public nsISupports {
  540.  public: 
  541.  
  542.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_UTILS_SANDBOX_IID)
  543.  
  544. };
  545.  
  546. /* Use this macro when declaring classes that implement this interface. */
  547. #define NS_DECL_NSIXPCCOMPONENTS_UTILS_SANDBOX \
  548.   /* no methods! */
  549.  
  550. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  551. #define NS_FORWARD_NSIXPCCOMPONENTS_UTILS_SANDBOX(_to) \
  552.   /* no methods! */
  553.  
  554. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  555. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS_UTILS_SANDBOX(_to) \
  556.   /* no methods! */
  557.  
  558. #if 0
  559. /* Use the code below as a template for the implementation class for this interface. */
  560.  
  561. /* Header file */
  562. class nsXPCComponents_utils_Sandbox : public nsIXPCComponents_utils_Sandbox
  563. {
  564. public:
  565.   NS_DECL_ISUPPORTS
  566.   NS_DECL_NSIXPCCOMPONENTS_UTILS_SANDBOX
  567.  
  568.   nsXPCComponents_utils_Sandbox();
  569.  
  570. private:
  571.   ~nsXPCComponents_utils_Sandbox();
  572.  
  573. protected:
  574.   /* additional members */
  575. };
  576.  
  577. /* Implementation file */
  578. NS_IMPL_ISUPPORTS1(nsXPCComponents_utils_Sandbox, nsIXPCComponents_utils_Sandbox)
  579.  
  580. nsXPCComponents_utils_Sandbox::nsXPCComponents_utils_Sandbox()
  581. {
  582.   /* member initializers and constructor code */
  583. }
  584.  
  585. nsXPCComponents_utils_Sandbox::~nsXPCComponents_utils_Sandbox()
  586. {
  587.   /* destructor code */
  588. }
  589.  
  590. /* End of implementation class template. */
  591. #endif
  592.  
  593.  
  594. /* starting interface:    nsIXPCComponents_Utils */
  595. #define NS_IXPCCOMPONENTS_UTILS_IID_STR "bcd54a63-34d9-468c-9a55-0fb5d2d8c677"
  596.  
  597. #define NS_IXPCCOMPONENTS_UTILS_IID \
  598.   {0xbcd54a63, 0x34d9, 0x468c, \
  599.     { 0x9a, 0x55, 0x0f, 0xb5, 0xd2, 0xd8, 0xc6, 0x77 }}
  600.  
  601. /**
  602. * interface of Components.utils
  603. */
  604. class NS_NO_VTABLE nsIXPCComponents_Utils : public nsISupports {
  605.  public: 
  606.  
  607.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_UTILS_IID)
  608.  
  609.   /* void reportError (); */
  610.   NS_IMETHOD ReportError(void) = 0;
  611.  
  612.   /* void lookupMethod (); */
  613.   NS_IMETHOD LookupMethod(void) = 0;
  614.  
  615.   /* readonly attribute nsIXPCComponents_utils_Sandbox Sandbox; */
  616.   NS_IMETHOD GetSandbox(nsIXPCComponents_utils_Sandbox * *aSandbox) = 0;
  617.  
  618.   /* void evalInSandbox (in AString source); */
  619.   NS_IMETHOD EvalInSandbox(const nsAString & source) = 0;
  620.  
  621. };
  622.  
  623. /* Use this macro when declaring classes that implement this interface. */
  624. #define NS_DECL_NSIXPCCOMPONENTS_UTILS \
  625.   NS_IMETHOD ReportError(void); \
  626.   NS_IMETHOD LookupMethod(void); \
  627.   NS_IMETHOD GetSandbox(nsIXPCComponents_utils_Sandbox * *aSandbox); \
  628.   NS_IMETHOD EvalInSandbox(const nsAString & source); 
  629.  
  630. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  631. #define NS_FORWARD_NSIXPCCOMPONENTS_UTILS(_to) \
  632.   NS_IMETHOD ReportError(void) { return _to ReportError(); } \
  633.   NS_IMETHOD LookupMethod(void) { return _to LookupMethod(); } \
  634.   NS_IMETHOD GetSandbox(nsIXPCComponents_utils_Sandbox * *aSandbox) { return _to GetSandbox(aSandbox); } \
  635.   NS_IMETHOD EvalInSandbox(const nsAString & source) { return _to EvalInSandbox(source); } 
  636.  
  637. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  638. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS_UTILS(_to) \
  639.   NS_IMETHOD ReportError(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReportError(); } \
  640.   NS_IMETHOD LookupMethod(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->LookupMethod(); } \
  641.   NS_IMETHOD GetSandbox(nsIXPCComponents_utils_Sandbox * *aSandbox) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSandbox(aSandbox); } \
  642.   NS_IMETHOD EvalInSandbox(const nsAString & source) { return !_to ? NS_ERROR_NULL_POINTER : _to->EvalInSandbox(source); } 
  643.  
  644. #if 0
  645. /* Use the code below as a template for the implementation class for this interface. */
  646.  
  647. /* Header file */
  648. class nsXPCComponents_Utils : public nsIXPCComponents_Utils
  649. {
  650. public:
  651.   NS_DECL_ISUPPORTS
  652.   NS_DECL_NSIXPCCOMPONENTS_UTILS
  653.  
  654.   nsXPCComponents_Utils();
  655.  
  656. private:
  657.   ~nsXPCComponents_Utils();
  658.  
  659. protected:
  660.   /* additional members */
  661. };
  662.  
  663. /* Implementation file */
  664. NS_IMPL_ISUPPORTS1(nsXPCComponents_Utils, nsIXPCComponents_Utils)
  665.  
  666. nsXPCComponents_Utils::nsXPCComponents_Utils()
  667. {
  668.   /* member initializers and constructor code */
  669. }
  670.  
  671. nsXPCComponents_Utils::~nsXPCComponents_Utils()
  672. {
  673.   /* destructor code */
  674. }
  675.  
  676. /* void reportError (); */
  677. NS_IMETHODIMP nsXPCComponents_Utils::ReportError()
  678. {
  679.     return NS_ERROR_NOT_IMPLEMENTED;
  680. }
  681.  
  682. /* void lookupMethod (); */
  683. NS_IMETHODIMP nsXPCComponents_Utils::LookupMethod()
  684. {
  685.     return NS_ERROR_NOT_IMPLEMENTED;
  686. }
  687.  
  688. /* readonly attribute nsIXPCComponents_utils_Sandbox Sandbox; */
  689. NS_IMETHODIMP nsXPCComponents_Utils::GetSandbox(nsIXPCComponents_utils_Sandbox * *aSandbox)
  690. {
  691.     return NS_ERROR_NOT_IMPLEMENTED;
  692. }
  693.  
  694. /* void evalInSandbox (in AString source); */
  695. NS_IMETHODIMP nsXPCComponents_Utils::EvalInSandbox(const nsAString & source)
  696. {
  697.     return NS_ERROR_NOT_IMPLEMENTED;
  698. }
  699.  
  700. /* End of implementation class template. */
  701. #endif
  702.  
  703.  
  704. /* starting interface:    nsIXPCComponents */
  705. #define NS_IXPCCOMPONENTS_IID_STR "155809f1-71f1-47c5-be97-d812ba560405"
  706.  
  707. #define NS_IXPCCOMPONENTS_IID \
  708.   {0x155809f1, 0x71f1, 0x47c5, \
  709.     { 0xbe, 0x97, 0xd8, 0x12, 0xba, 0x56, 0x04, 0x05 }}
  710.  
  711. /**
  712. * interface of JavaScript's 'Components' object
  713. */
  714. class NS_NO_VTABLE nsIXPCComponents : public nsISupports {
  715.  public: 
  716.  
  717.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCCOMPONENTS_IID)
  718.  
  719.   /* readonly attribute nsIScriptableInterfaces interfaces; */
  720.   NS_IMETHOD GetInterfaces(nsIScriptableInterfaces * *aInterfaces) = 0;
  721.  
  722.   /* readonly attribute nsIScriptableInterfacesByID interfacesByID; */
  723.   NS_IMETHOD GetInterfacesByID(nsIScriptableInterfacesByID * *aInterfacesByID) = 0;
  724.  
  725.   /* readonly attribute nsIXPCComponents_Classes classes; */
  726.   NS_IMETHOD GetClasses(nsIXPCComponents_Classes * *aClasses) = 0;
  727.  
  728.   /* readonly attribute nsIXPCComponents_ClassesByID classesByID; */
  729.   NS_IMETHOD GetClassesByID(nsIXPCComponents_ClassesByID * *aClassesByID) = 0;
  730.  
  731.   /* readonly attribute nsIStackFrame stack; */
  732.   NS_IMETHOD GetStack(nsIStackFrame * *aStack) = 0;
  733.  
  734.   /* readonly attribute nsIXPCComponents_Results results; */
  735.   NS_IMETHOD GetResults(nsIXPCComponents_Results * *aResults) = 0;
  736.  
  737.   /* readonly attribute nsIComponentManager manager; */
  738.   NS_IMETHOD GetManager(nsIComponentManager * *aManager) = 0;
  739.  
  740.   /* readonly attribute nsIXPCComponents_Utils utils; */
  741.   NS_IMETHOD GetUtils(nsIXPCComponents_Utils * *aUtils) = 0;
  742.  
  743.   /* readonly attribute nsIXPCComponents_ID ID; */
  744.   NS_IMETHOD GetID(nsIXPCComponents_ID * *aID) = 0;
  745.  
  746.   /* readonly attribute nsIXPCComponents_Exception Exception; */
  747.   NS_IMETHOD GetException(nsIXPCComponents_Exception * *aException) = 0;
  748.  
  749.   /* readonly attribute nsIXPCComponents_Constructor Constructor; */
  750.   NS_IMETHOD GetConstructor(nsIXPCComponents_Constructor * *aConstructor) = 0;
  751.  
  752.   /* boolean isSuccessCode (in nsresult result); */
  753.   NS_IMETHOD IsSuccessCode(nsresult result, PRBool *_retval) = 0;
  754.  
  755.   /* void lookupMethod (); */
  756.   NS_IMETHOD LookupMethod(void) = 0;
  757.  
  758.   /* void reportError (); */
  759.   NS_IMETHOD ReportError(void) = 0;
  760.  
  761. };
  762.  
  763. /* Use this macro when declaring classes that implement this interface. */
  764. #define NS_DECL_NSIXPCCOMPONENTS \
  765.   NS_IMETHOD GetInterfaces(nsIScriptableInterfaces * *aInterfaces); \
  766.   NS_IMETHOD GetInterfacesByID(nsIScriptableInterfacesByID * *aInterfacesByID); \
  767.   NS_IMETHOD GetClasses(nsIXPCComponents_Classes * *aClasses); \
  768.   NS_IMETHOD GetClassesByID(nsIXPCComponents_ClassesByID * *aClassesByID); \
  769.   NS_IMETHOD GetStack(nsIStackFrame * *aStack); \
  770.   NS_IMETHOD GetResults(nsIXPCComponents_Results * *aResults); \
  771.   NS_IMETHOD GetManager(nsIComponentManager * *aManager); \
  772.   NS_IMETHOD GetUtils(nsIXPCComponents_Utils * *aUtils); \
  773.   NS_IMETHOD GetID(nsIXPCComponents_ID * *aID); \
  774.   NS_IMETHOD GetException(nsIXPCComponents_Exception * *aException); \
  775.   NS_IMETHOD GetConstructor(nsIXPCComponents_Constructor * *aConstructor); \
  776.   NS_IMETHOD IsSuccessCode(nsresult result, PRBool *_retval); \
  777.   NS_IMETHOD LookupMethod(void); \
  778.   NS_IMETHOD ReportError(void); 
  779.  
  780. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  781. #define NS_FORWARD_NSIXPCCOMPONENTS(_to) \
  782.   NS_IMETHOD GetInterfaces(nsIScriptableInterfaces * *aInterfaces) { return _to GetInterfaces(aInterfaces); } \
  783.   NS_IMETHOD GetInterfacesByID(nsIScriptableInterfacesByID * *aInterfacesByID) { return _to GetInterfacesByID(aInterfacesByID); } \
  784.   NS_IMETHOD GetClasses(nsIXPCComponents_Classes * *aClasses) { return _to GetClasses(aClasses); } \
  785.   NS_IMETHOD GetClassesByID(nsIXPCComponents_ClassesByID * *aClassesByID) { return _to GetClassesByID(aClassesByID); } \
  786.   NS_IMETHOD GetStack(nsIStackFrame * *aStack) { return _to GetStack(aStack); } \
  787.   NS_IMETHOD GetResults(nsIXPCComponents_Results * *aResults) { return _to GetResults(aResults); } \
  788.   NS_IMETHOD GetManager(nsIComponentManager * *aManager) { return _to GetManager(aManager); } \
  789.   NS_IMETHOD GetUtils(nsIXPCComponents_Utils * *aUtils) { return _to GetUtils(aUtils); } \
  790.   NS_IMETHOD GetID(nsIXPCComponents_ID * *aID) { return _to GetID(aID); } \
  791.   NS_IMETHOD GetException(nsIXPCComponents_Exception * *aException) { return _to GetException(aException); } \
  792.   NS_IMETHOD GetConstructor(nsIXPCComponents_Constructor * *aConstructor) { return _to GetConstructor(aConstructor); } \
  793.   NS_IMETHOD IsSuccessCode(nsresult result, PRBool *_retval) { return _to IsSuccessCode(result, _retval); } \
  794.   NS_IMETHOD LookupMethod(void) { return _to LookupMethod(); } \
  795.   NS_IMETHOD ReportError(void) { return _to ReportError(); } 
  796.  
  797. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  798. #define NS_FORWARD_SAFE_NSIXPCCOMPONENTS(_to) \
  799.   NS_IMETHOD GetInterfaces(nsIScriptableInterfaces * *aInterfaces) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetInterfaces(aInterfaces); } \
  800.   NS_IMETHOD GetInterfacesByID(nsIScriptableInterfacesByID * *aInterfacesByID) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetInterfacesByID(aInterfacesByID); } \
  801.   NS_IMETHOD GetClasses(nsIXPCComponents_Classes * *aClasses) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetClasses(aClasses); } \
  802.   NS_IMETHOD GetClassesByID(nsIXPCComponents_ClassesByID * *aClassesByID) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetClassesByID(aClassesByID); } \
  803.   NS_IMETHOD GetStack(nsIStackFrame * *aStack) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStack(aStack); } \
  804.   NS_IMETHOD GetResults(nsIXPCComponents_Results * *aResults) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetResults(aResults); } \
  805.   NS_IMETHOD GetManager(nsIComponentManager * *aManager) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetManager(aManager); } \
  806.   NS_IMETHOD GetUtils(nsIXPCComponents_Utils * *aUtils) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUtils(aUtils); } \
  807.   NS_IMETHOD GetID(nsIXPCComponents_ID * *aID) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetID(aID); } \
  808.   NS_IMETHOD GetException(nsIXPCComponents_Exception * *aException) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetException(aException); } \
  809.   NS_IMETHOD GetConstructor(nsIXPCComponents_Constructor * *aConstructor) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetConstructor(aConstructor); } \
  810.   NS_IMETHOD IsSuccessCode(nsresult result, PRBool *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->IsSuccessCode(result, _retval); } \
  811.   NS_IMETHOD LookupMethod(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->LookupMethod(); } \
  812.   NS_IMETHOD ReportError(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReportError(); } 
  813.  
  814. #if 0
  815. /* Use the code below as a template for the implementation class for this interface. */
  816.  
  817. /* Header file */
  818. class nsXPCComponents : public nsIXPCComponents
  819. {
  820. public:
  821.   NS_DECL_ISUPPORTS
  822.   NS_DECL_NSIXPCCOMPONENTS
  823.  
  824.   nsXPCComponents();
  825.  
  826. private:
  827.   ~nsXPCComponents();
  828.  
  829. protected:
  830.   /* additional members */
  831. };
  832.  
  833. /* Implementation file */
  834. NS_IMPL_ISUPPORTS1(nsXPCComponents, nsIXPCComponents)
  835.  
  836. nsXPCComponents::nsXPCComponents()
  837. {
  838.   /* member initializers and constructor code */
  839. }
  840.  
  841. nsXPCComponents::~nsXPCComponents()
  842. {
  843.   /* destructor code */
  844. }
  845.  
  846. /* readonly attribute nsIScriptableInterfaces interfaces; */
  847. NS_IMETHODIMP nsXPCComponents::GetInterfaces(nsIScriptableInterfaces * *aInterfaces)
  848. {
  849.     return NS_ERROR_NOT_IMPLEMENTED;
  850. }
  851.  
  852. /* readonly attribute nsIScriptableInterfacesByID interfacesByID; */
  853. NS_IMETHODIMP nsXPCComponents::GetInterfacesByID(nsIScriptableInterfacesByID * *aInterfacesByID)
  854. {
  855.     return NS_ERROR_NOT_IMPLEMENTED;
  856. }
  857.  
  858. /* readonly attribute nsIXPCComponents_Classes classes; */
  859. NS_IMETHODIMP nsXPCComponents::GetClasses(nsIXPCComponents_Classes * *aClasses)
  860. {
  861.     return NS_ERROR_NOT_IMPLEMENTED;
  862. }
  863.  
  864. /* readonly attribute nsIXPCComponents_ClassesByID classesByID; */
  865. NS_IMETHODIMP nsXPCComponents::GetClassesByID(nsIXPCComponents_ClassesByID * *aClassesByID)
  866. {
  867.     return NS_ERROR_NOT_IMPLEMENTED;
  868. }
  869.  
  870. /* readonly attribute nsIStackFrame stack; */
  871. NS_IMETHODIMP nsXPCComponents::GetStack(nsIStackFrame * *aStack)
  872. {
  873.     return NS_ERROR_NOT_IMPLEMENTED;
  874. }
  875.  
  876. /* readonly attribute nsIXPCComponents_Results results; */
  877. NS_IMETHODIMP nsXPCComponents::GetResults(nsIXPCComponents_Results * *aResults)
  878. {
  879.     return NS_ERROR_NOT_IMPLEMENTED;
  880. }
  881.  
  882. /* readonly attribute nsIComponentManager manager; */
  883. NS_IMETHODIMP nsXPCComponents::GetManager(nsIComponentManager * *aManager)
  884. {
  885.     return NS_ERROR_NOT_IMPLEMENTED;
  886. }
  887.  
  888. /* readonly attribute nsIXPCComponents_Utils utils; */
  889. NS_IMETHODIMP nsXPCComponents::GetUtils(nsIXPCComponents_Utils * *aUtils)
  890. {
  891.     return NS_ERROR_NOT_IMPLEMENTED;
  892. }
  893.  
  894. /* readonly attribute nsIXPCComponents_ID ID; */
  895. NS_IMETHODIMP nsXPCComponents::GetID(nsIXPCComponents_ID * *aID)
  896. {
  897.     return NS_ERROR_NOT_IMPLEMENTED;
  898. }
  899.  
  900. /* readonly attribute nsIXPCComponents_Exception Exception; */
  901. NS_IMETHODIMP nsXPCComponents::GetException(nsIXPCComponents_Exception * *aException)
  902. {
  903.     return NS_ERROR_NOT_IMPLEMENTED;
  904. }
  905.  
  906. /* readonly attribute nsIXPCComponents_Constructor Constructor; */
  907. NS_IMETHODIMP nsXPCComponents::GetConstructor(nsIXPCComponents_Constructor * *aConstructor)
  908. {
  909.     return NS_ERROR_NOT_IMPLEMENTED;
  910. }
  911.  
  912. /* boolean isSuccessCode (in nsresult result); */
  913. NS_IMETHODIMP nsXPCComponents::IsSuccessCode(nsresult result, PRBool *_retval)
  914. {
  915.     return NS_ERROR_NOT_IMPLEMENTED;
  916. }
  917.  
  918. /* void lookupMethod (); */
  919. NS_IMETHODIMP nsXPCComponents::LookupMethod()
  920. {
  921.     return NS_ERROR_NOT_IMPLEMENTED;
  922. }
  923.  
  924. /* void reportError (); */
  925. NS_IMETHODIMP nsXPCComponents::ReportError()
  926. {
  927.     return NS_ERROR_NOT_IMPLEMENTED;
  928. }
  929.  
  930. /* End of implementation class template. */
  931. #endif
  932.  
  933.  
  934. #endif /* __gen_xpccomponents_h__ */
  935.